/**
 * 认证中间件
 * Authentication Middleware
 */

const jwt = require('jsonwebtoken');
const config = require('../config/config');
const logger = require('../utils/logger');
const sessionService = require('../services/SessionService');

/**
 * JWT认证中间件
 */
const authMiddleware = (req, res, next) => {
  try {
    const authHeader = req.headers.authorization;

    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({
        success: false,
        message: '缺少认证令牌 / Missing authentication token'
      });
    }

    const token = authHeader.substring(7);

    // 验证JWT令牌
    const decoded = jwt.verify(token, config.jwt.secret);

    // 验证会话
    const user = sessionService.validateSession(decoded.sessionId);
    
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '会话已过期 / Session expired'
      });
    }

    // 将用户信息添加到请求对象
    req.user = user;

    next();
  } catch (error) {
    logger.warn('认证失败 / Authentication failed', {
      error: error.message,
      ip: req.ip,
      userAgent: req.get('User-Agent')
    });

    if (error.name === 'JsonWebTokenError') {
      return res.status(401).json({
        success: false,
        message: '无效的认证令牌 / Invalid authentication token'
      });
    }

    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({
        success: false,
        message: '认证令牌已过期 / Authentication token expired'
      });
    }

    return res.status(500).json({
      success: false,
      message: '认证服务错误 / Authentication service error'
    });
  }
};

/**
 * 管理员权限中间件
 */
const adminMiddleware = (req, res, next) => {
  if (!req.user) {
    return res.status(401).json({
      success: false,
      message: '未认证 / Not authenticated'
    });
  }

  if (req.user.role !== 'admin') {
    return res.status(403).json({
      success: false,
      message: '需要管理员权限 / Admin privileges required'
    });
  }
  next();
};

/**
 * 创建会话（委托给会话服务）
 */
const createSession = (user, options = {}) => {
  return sessionService.createSession(user, options);
};

/**
 * 销毁会话（委托给会话服务）
 */
const destroySession = (sessionId) => {
  return sessionService.destroySession(sessionId);
};

/**
 * 销毁用户的所有会话（委托给会话服务）
 */
const destroyUserSessions = (userId) => {
  return sessionService.destroyUserSessions(userId);
};

/**
 * 清理过期会话（委托给会话服务）
 */
const cleanExpiredSessions = () => {
  return sessionService.cleanupExpiredSessions();
};

/**
 * 获取用户的活跃会话（委托给会话服务）
 */
const getUserSessions = (userId) => {
  return sessionService.getUserSessions(userId);
};

/**
 * 获取活跃会话统计（委托给会话服务）
 */
const getSessionStats = () => {
  return sessionService.getSessionStats();
};

/**
 * 可选的认证中间件（不强制要求认证）
 */
const optionalAuthMiddleware = (req, res, next) => {
  const authHeader = req.headers.authorization;

  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    // 没有认证信息，继续处理但不设置用户信息
    return next();
  }

  try {
    const token = authHeader.substring(7);
    const decoded = jwt.verify(token, config.jwt.secret);
    
    // 验证会话
    const user = sessionService.validateSession(decoded.sessionId);
    
    if (user) {
      req.user = user;
    }
  } catch (error) {
    // 忽略认证错误，继续处理请求
    logger.debug('可选认证失败 / Optional authentication failed', {
      error: error.message
    });
  }

  next();
};

module.exports = {
  authMiddleware,
  adminMiddleware,
  optionalAuthMiddleware,
  createSession,
  destroySession,
  destroyUserSessions,
  cleanExpiredSessions,
  getUserSessions,
  getSessionStats
};